// ../../../../common/web/types/src/util/util.ts
  var util_exports = {};
  __export(util_exports, {
    BadStringAnalyzer: () => BadStringAnalyzer,
    BadStringType: () => BadStringType,
    CONTAINS_QUAD_ESCAPE: () => CONTAINS_QUAD_ESCAPE,
    MATCH_HEX_ESCAPE: () => MATCH_HEX_ESCAPE,
    MATCH_QUAD_ESCAPE: () => MATCH_QUAD_ESCAPE,
    NFDAnalyzer: () => NFDAnalyzer,
    StringAnalyzer: () => StringAnalyzer,
    UnescapeError: () => UnescapeError,
    Uni_IsSurrogate: () => Uni_IsSurrogate,
    Uni_IsSurrogate1: () => Uni_IsSurrogate1,
    Uni_IsSurrogate2: () => Uni_IsSurrogate2,
    boxXmlArray: () => boxXmlArray,
    describeCodepoint: () => describeCodepoint,
    escapeRegexChar: () => escapeRegexChar,
    escapeStringForRegex: () => escapeStringForRegex,
    hexOcts: () => hexOcts,
    hexQuad: () => hexQuad,
    isOneChar: () => isOneChar,
    isPUA: () => isPUA,
    isValidUnicode: () => isValidUnicode,
    toOneChar: () => toOneChar,
    unescapeOne: () => unescapeOne,
    unescapeOneQuadString: () => unescapeOneQuadString,
    unescapeQuadString: () => unescapeQuadString,
    unescapeString: () => unescapeString,
    unescapeStringToRegex: () => unescapeStringToRegex
  });
  function boxXmlArray(o, x) {
    if (typeof o == "object" && !Array.isArray(o[x])) {
      if (o[x] === null || o[x] === void 0) {
        o[x] = [];
      } else {
        o[x] = [o[x]];
      }
    }
  }
  __name(boxXmlArray, "boxXmlArray");
  var MATCH_HEX_ESCAPE = /\\u{([0-9a-fA-F ]{1,})}/g;
  var CONTAINS_QUAD_ESCAPE = /(?:\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{8}))/;
  var MATCH_QUAD_ESCAPE = new RegExp(CONTAINS_QUAD_ESCAPE, "g");
  var _UnescapeError = class _UnescapeError extends Error {
  };
  __name(_UnescapeError, "UnescapeError");
  var UnescapeError = _UnescapeError;
  function unescapeOne(hex) {
    const codepoint = Number.parseInt(hex, 16);
    return String.fromCodePoint(codepoint);
  }
  __name(unescapeOne, "unescapeOne");
  function unescapeOneQuadString(s) {
    if (!s || !s.match(MATCH_QUAD_ESCAPE)) {
      throw new UnescapeError(`Not a quad escape: ${s}`);
    }
    function processMatch(str, m16, m32) {
      return unescapeOne(m16 || m32);
    }
    __name(processMatch, "processMatch");
    s = s.replace(MATCH_QUAD_ESCAPE, processMatch);
    return s;
  }
  __name(unescapeOneQuadString, "unescapeOneQuadString");
  function unescapeQuadString(s) {
    s = s.replaceAll(MATCH_QUAD_ESCAPE, (quad) => unescapeOneQuadString(quad));
    return s;
  }
  __name(unescapeQuadString, "unescapeQuadString");
  function unescapeString(s) {
    if (!s) {
      return s;
    }
    try {
      let processMatch2 = function(str, matched) {
        const codepoints = matched.split(" ");
        const unescaped = codepoints.map(unescapeOne);
        return unescaped.join("");
      };
      var processMatch = processMatch2;
      __name(processMatch2, "processMatch");
      s = s.replaceAll(MATCH_HEX_ESCAPE, processMatch2);
    } catch (e) {
      if (e instanceof RangeError) {
        throw new UnescapeError(`Out of range while unescaping '${s}': ${e.message}`, { cause: e });
      } else {
        throw e;
      }
    }
    return s;
  }
  __name(unescapeString, "unescapeString");
  function hexQuad(n) {
    if (n < 0 || n > 65535) {
      throw RangeError(`${n} not in [0x0000,0xFFFF]`);
    }
    return n.toString(16).padStart(4, "0");
  }
  __name(hexQuad, "hexQuad");
  function hexOcts(n) {
    if (n < 0 || n > 4294967295) {
      throw RangeError(`${n} not in [0x00000000,0xFFFFFFFF]`);
    }
    return n.toString(16).padStart(8, "0");
  }
  __name(hexOcts, "hexOcts");
  function escapeRegexChar(ch) {
    const code = ch.codePointAt(0);
    if (code <= 65535) {
      return "\\u" + hexQuad(code);
    } else {
      return "\\U" + hexOcts(code);
    }
  }
  __name(escapeRegexChar, "escapeRegexChar");
  var REGEX_SYNTAX_CHAR = /^[\u0000-\u001F\u007F-\u009F{}\[\]\\?|.^$*()/+-]$/;
  function escapeRegexCharIfSyntax(ch) {
    if (REGEX_SYNTAX_CHAR.test(ch) || !isValidUnicode(ch.codePointAt(0))) {
      return escapeRegexChar(ch);
    } else {
      return ch;
    }
  }
  __name(escapeRegexCharIfSyntax, "escapeRegexCharIfSyntax");
  function regexOne(hex) {
    const unescaped = unescapeOne(hex);
    return Array.from(unescaped).map((ch) => escapeRegexCharIfSyntax(ch)).join("");
  }
  __name(regexOne, "regexOne");
  function escapeStringForRegex(s) {
    return s.split("").map((ch) => escapeRegexCharIfSyntax(ch)).join("");
  }
  __name(escapeStringForRegex, "escapeStringForRegex");
  function unescapeStringToRegex(s) {
    if (!s) {
      return s;
    }
    try {
      let processMatch2 = function(str, matched) {
        const codepoints = matched.split(" ");
        const unescaped = codepoints.map(regexOne);
        return unescaped.join("");
      };
      var processMatch = processMatch2;
      __name(processMatch2, "processMatch");
      s = s.replaceAll(MATCH_HEX_ESCAPE, processMatch2);
    } catch (e) {
      if (e instanceof RangeError) {
        throw new UnescapeError(`Out of range while unescaping '${s}': ${e.message}`, { cause: e });
      } else {
        throw e;
      }
    }
    return s;
  }
  __name(unescapeStringToRegex, "unescapeStringToRegex");
  function isOneChar(value) {
    return [...value].length === 1;
  }
  __name(isOneChar, "isOneChar");
  function toOneChar(value) {
    if (!isOneChar(value)) {
      throw Error(`Not a single char: ${value}`);
    }
    return value.codePointAt(0);
  }
  __name(toOneChar, "toOneChar");
  function describeCodepoint(ch) {
    let s;
    const p = BadStringAnalyzer.getProblem(ch);
    if (p != null) {
      s = p;
    } else {
      s = `"${String.fromCodePoint(ch)}"`;
    }
    return `${s} (U+${Number(ch).toString(16).toUpperCase()})`;
  }
  __name(describeCodepoint, "describeCodepoint");
  var BadStringType = /* @__PURE__ */ ((BadStringType2) => {
    BadStringType2["pua"] = "PUA";
    BadStringType2["unassigned"] = "Unassigned";
    BadStringType2["illegal"] = "Illegal";
    BadStringType2["denormalized"] = "Denormalized";
    return BadStringType2;
  })(BadStringType || {});
  var Uni_LEAD_SURROGATE_START = 55296;
  var Uni_LEAD_SURROGATE_END = 56319;
  var Uni_TRAIL_SURROGATE_START = 56320;
  var Uni_TRAIL_SURROGATE_END = 57343;
  var Uni_SURROGATE_START = Uni_LEAD_SURROGATE_START;
  var Uni_SURROGATE_END = Uni_TRAIL_SURROGATE_END;
  var Uni_FD_NONCHARACTER_START = 64976;
  var Uni_FD_NONCHARACTER_END = 65007;
  var Uni_FFFE_NONCHARACTER = 65534;
  var Uni_PLANE_MASK = 2031616;
  var Uni_MAX_CODEPOINT = 1114111;
  var Uni_PUA_00_START = 57344;
  var Uni_PUA_00_END = 63743;
  var Uni_PUA_15_START = 983040;
  var Uni_PUA_15_END = 1048573;
  var Uni_PUA_16_START = 1048576;
  var Uni_PUA_16_END = 1114109;
  function Uni_IsSurrogate1(ch) {
    return ch >= Uni_LEAD_SURROGATE_START && ch <= Uni_LEAD_SURROGATE_END;
  }
  __name(Uni_IsSurrogate1, "Uni_IsSurrogate1");
  function Uni_IsSurrogate2(ch) {
    return ch >= Uni_TRAIL_SURROGATE_START && ch <= Uni_TRAIL_SURROGATE_END;
  }
  __name(Uni_IsSurrogate2, "Uni_IsSurrogate2");
  function Uni_IsSurrogate(ch) {
    return Uni_IsSurrogate1(ch) || Uni_IsSurrogate2(ch);
  }
  __name(Uni_IsSurrogate, "Uni_IsSurrogate");
  function Uni_IsEndOfPlaneNonCharacter(ch) {
    return (ch & Uni_FFFE_NONCHARACTER) == Uni_FFFE_NONCHARACTER;
  }
  __name(Uni_IsEndOfPlaneNonCharacter, "Uni_IsEndOfPlaneNonCharacter");
  function Uni_IsNoncharacter(ch) {
    return ch >= Uni_FD_NONCHARACTER_START && ch <= Uni_FD_NONCHARACTER_END || Uni_IsEndOfPlaneNonCharacter(ch);
  }
  __name(Uni_IsNoncharacter, "Uni_IsNoncharacter");
  function Uni_InCodespace(ch) {
    return ch >= 0 && ch <= Uni_MAX_CODEPOINT;
  }
  __name(Uni_InCodespace, "Uni_InCodespace");
  function Uni_IsValid1(ch) {
    return Uni_InCodespace(ch) && !Uni_IsSurrogate(ch) && !Uni_IsNoncharacter(ch);
  }
  __name(Uni_IsValid1, "Uni_IsValid1");
  function isValidUnicode(start, end) {
    if (!end) {
      return Uni_IsValid1(start);
    } else if (!Uni_IsValid1(end) || !Uni_IsValid1(start) || end < start) {
      return false;
    } else if (start <= Uni_SURROGATE_END && end >= Uni_SURROGATE_START) {
      return false;
    } else if (start <= Uni_FD_NONCHARACTER_END && end >= Uni_FD_NONCHARACTER_START) {
      return false;
    } else if ((start & Uni_PLANE_MASK) != (end & Uni_PLANE_MASK)) {
      return false;
    } else {
      return true;
    }
  }
  __name(isValidUnicode, "isValidUnicode");
  function isPUA(ch) {
    return ch >= Uni_PUA_00_START && ch <= Uni_PUA_00_END || ch >= Uni_PUA_15_START && ch <= Uni_PUA_15_END || ch >= Uni_PUA_16_START && ch <= Uni_PUA_16_END;
  }
  __name(isPUA, "isPUA");
  var _BadStringMap = class _BadStringMap extends Map {
    toString() {
      if (!this.size) {
        return "{}";
      }
      return Array.from(this.entries()).map(([t, s]) => `${t}: ${Array.from(s.values()).map(describeCodepoint).join(" ")}`).join(", ");
    }
  };
  __name(_BadStringMap, "BadStringMap");
  var BadStringMap = _BadStringMap;
  var _StringAnalyzer = class _StringAnalyzer {
    constructor() {
      /** internal map */
      __publicField(this, "m", new BadStringMap());
    }
    /** add a string for analysis */
    add(s) {
      for (const c of [...s]) {
        const ch = c.codePointAt(0);
        const problem = this.analyzeCodePoint(c, ch);
        if (problem) {
          this.addProblem(ch, problem);
        }
      }
    }
    /** internal interface for the result of an analysis */
    addProblem(ch, type) {
      if (!this.m.has(type)) {
        this.m.set(type, /* @__PURE__ */ new Set());
      }
      this.m.get(type).add(ch);
    }
    /** get the results of the analysis */
    analyze() {
      if (this.m.size == 0) {
        return null;
      } else {
        return this.m;
      }
    }
  };
  __name(_StringAnalyzer, "StringAnalyzer");
  var StringAnalyzer = _StringAnalyzer;
  var _BadStringAnalyzer = class _BadStringAnalyzer extends StringAnalyzer {
    /** analyze one codepoint */
    analyzeCodePoint(c, ch) {
      return _BadStringAnalyzer.getProblem(ch);
    }
    /** export analyzer function  */
    static getProblem(ch) {
      if (!isValidUnicode(ch)) {
        return "Illegal" /* illegal */;
      } else if (isPUA(ch)) {
        return "PUA" /* pua */;
      } else {
        return null;
      }
    }
  };
  __name(_BadStringAnalyzer, "BadStringAnalyzer");
  var BadStringAnalyzer = _BadStringAnalyzer;
  var _NFDAnalyzer = class _NFDAnalyzer extends StringAnalyzer {
    analyzeCodePoint(c, ch) {
      const nfd = c.normalize("NFD");
      if (c !== nfd) {
        return "Denormalized" /* denormalized */;
      } else {
        return null;
      }
    }
  };
  __name(_NFDAnalyzer, "NFDAnalyzer");
  var NFDAnalyzer = _NFDAnalyzer;